Object-sensitive cost analysis for concurrent objects

Compilation. This section describes how to transform a program P into an abstract program P, which can be seen as an abstraction of P with respect to the chosen size measure α. The translation is based on replacing each instruction by (linear) constraints which describe its behaviour with respect to the size measure. For example, the instruction x := new C can be replaced by the constraint x = 1 which indicates that the reference variable is different from null. The fact that the formula takes this form is due to the previous choice of size measure for references in Definition 7. In order to simplify the presentation, when it is clear from the context, the same name is used for the original variables (possibly primed or subscripted) and their symbolic sizes. That is, given an integer variable x, the name x is also used in the abstract compilation to denote its value. An important issue in the presented setting is to be able to obtain relations between the size of a variable at different program points. For example, in the size analysis of x := x+ 1, the interest is in the relation ”the value of x after the instruction is equal to the value of x before the instruction plus 1”. This important piece of information can be obtained by using a Static Single Assignment (SSA) transformation, which, together with the abstract compilation, produces the constraint x′ = x+ 1, where x and x′ refer to, respectively, the value of x before and after executing the instruction. To implement the SSA transformation, a mapping ρ of variable names to new variable names (constraint variables) is maintained. Such mapping is referred to as a renaming. The expression ρ[x̄ 7→ ȳ] denotes the update performed by ρ, such that it maps variables x̄ to the new variables ȳ. Modeling shared memory is a main challenge in static analysis of OO programs. Our starting point is [5], which models fields as local variables when the field to be tracked satisfies two soundness conditions: (1) its memory location does not change; and (2) it is always accessed through the same reference (i.e., not through aliases). Both conditions can often be proven statically and the transformation of fields into local variables can then be applied for many fragments of the program. If we ignore concurrency, this approach could be directly adopted for our language. However, concurrency introduces new challenges. Example 8 (treatment of fields at release points). Consider the loop in the readBlock method in Figure 1. Ignoring the await instruction, the above soundness conditions (1) and (2) hold for the field blockS, and hence, we can track it as if it was a local variable. In a concurrent setting, however, while readBlock is executing, another task in the same object might modify the field blockS. Therefore, when analyzing readBlock, we cannot assume that the value of blockS is locally trackable. For instance, readBlock might introduce non-termination if we add a method void p() {blockS = blockS− 2; } to class FileIS. When the await is executed inside the loop, method p might change the value of blockS to a non-positive value, and thus the loop counter i would not decrement. Copyright c © 0000 John Wiley & Sons, Ltd. Softw. Test. Verif. Reliab. (0000) Prepared using stvrauth.cls DOI: 10.1002/stvr 20 E. ALBERT, ET AL.